Termination w.r.t. Q proof of /tmp/tmp2IDRK8/thiemann33.trs

Termination w.r.t. Q of the following Term Rewriting System could be proven:

Q restricted rewrite system:
The TRS R consists of the following rules:

numbers → d(0)
d(x) → if(le(x, nr), x)
if(true, x) → cons(x, d(s(x)))
if(false, x) → nil
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
nr → ack(s(s(s(s(s(s(0)))))), 0)
ack(0, x) → s(x)
ack(s(x), 0) → ack(x, s(0))
ack(s(x), s(y)) → ack(x, ack(s(x), y))

Q is empty.

↳ QTRS

  ↳ Overlay + Local Confluence

Q restricted rewrite system:
The TRS R consists of the following rules:

numbers → d(0)
d(x) → if(le(x, nr), x)
if(true, x) → cons(x, d(s(x)))
if(false, x) → nil
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
nr → ack(s(s(s(s(s(s(0)))))), 0)
ack(0, x) → s(x)
ack(s(x), 0) → ack(x, s(0))
ack(s(x), s(y)) → ack(x, ack(s(x), y))

Q is empty.

The TRS is overlay and locally confluent. By [19] we can switch to innermost.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

numbers → d(0)
d(x) → if(le(x, nr), x)
if(true, x) → cons(x, d(s(x)))
if(false, x) → nil
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
nr → ack(s(s(s(s(s(s(0)))))), 0)
ack(0, x) → s(x)
ack(s(x), 0) → ack(x, s(0))
ack(s(x), s(y)) → ack(x, ack(s(x), y))

The set Q consists of the following terms:

numbers
d(x0)
if(true, x0)
if(false, x0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

ACK(s(x), 0) → ACK(x, s(0))
ACK(s(x), s(y)) → ACK(s(x), y)
NUMBERS → D(0)
ACK(s(x), s(y)) → ACK(x, ack(s(x), y))
D(x) → IF(le(x, nr), x)
D(x) → NR
D(x) → LE(x, nr)
NR → ACK(s(s(s(s(s(s(0)))))), 0)
IF(true, x) → D(s(x))
LE(s(x), s(y)) → LE(x, y)

The TRS R consists of the following rules:

numbers → d(0)
d(x) → if(le(x, nr), x)
if(true, x) → cons(x, d(s(x)))
if(false, x) → nil
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
nr → ack(s(s(s(s(s(s(0)))))), 0)
ack(0, x) → s(x)
ack(s(x), 0) → ack(x, s(0))
ack(s(x), s(y)) → ack(x, ack(s(x), y))

The set Q consists of the following terms:

numbers
d(x0)
if(true, x0)
if(false, x0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

ACK(s(x), 0) → ACK(x, s(0))
ACK(s(x), s(y)) → ACK(s(x), y)
NUMBERS → D(0)
ACK(s(x), s(y)) → ACK(x, ack(s(x), y))
D(x) → IF(le(x, nr), x)
D(x) → NR
D(x) → LE(x, nr)
NR → ACK(s(s(s(s(s(s(0)))))), 0)
IF(true, x) → D(s(x))
LE(s(x), s(y)) → LE(x, y)

The TRS R consists of the following rules:

numbers → d(0)
d(x) → if(le(x, nr), x)
if(true, x) → cons(x, d(s(x)))
if(false, x) → nil
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
nr → ack(s(s(s(s(s(s(0)))))), 0)
ack(0, x) → s(x)
ack(s(x), 0) → ack(x, s(0))
ack(s(x), s(y)) → ack(x, ack(s(x), y))

The set Q consists of the following terms:

numbers
d(x0)
if(true, x0)
if(false, x0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 3 SCCs with 4 less nodes.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACK(s(x), 0) → ACK(x, s(0))
ACK(s(x), s(y)) → ACK(s(x), y)
ACK(s(x), s(y)) → ACK(x, ack(s(x), y))

The TRS R consists of the following rules:

numbers → d(0)
d(x) → if(le(x, nr), x)
if(true, x) → cons(x, d(s(x)))
if(false, x) → nil
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
nr → ack(s(s(s(s(s(s(0)))))), 0)
ack(0, x) → s(x)
ack(s(x), 0) → ack(x, s(0))
ack(s(x), s(y)) → ack(x, ack(s(x), y))

The set Q consists of the following terms:

numbers
d(x0)
if(true, x0)
if(false, x0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACK(s(x), 0) → ACK(x, s(0))
ACK(s(x), s(y)) → ACK(s(x), y)
ACK(s(x), s(y)) → ACK(x, ack(s(x), y))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
ack(0, x) → s(x)

The set Q consists of the following terms:

numbers
d(x0)
if(true, x0)
if(false, x0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

numbers
d(x0)
if(true, x0)
if(false, x0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACK(s(x), 0) → ACK(x, s(0))
ACK(s(x), s(y)) → ACK(s(x), y)
ACK(s(x), s(y)) → ACK(x, ack(s(x), y))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
ack(0, x) → s(x)

The set Q consists of the following terms:

ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

ACK(s(x), s(y)) → ACK(s(x), y)
The graph contains the following edges 1 >= 1, 2 > 2
ACK(s(x), s(y)) → ACK(x, ack(s(x), y))
The graph contains the following edges 1 > 1
ACK(s(x), 0) → ACK(x, s(0))
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LE(s(x), s(y)) → LE(x, y)

The TRS R consists of the following rules:

numbers → d(0)
d(x) → if(le(x, nr), x)
if(true, x) → cons(x, d(s(x)))
if(false, x) → nil
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
nr → ack(s(s(s(s(s(s(0)))))), 0)
ack(0, x) → s(x)
ack(s(x), 0) → ack(x, s(0))
ack(s(x), s(y)) → ack(x, ack(s(x), y))

The set Q consists of the following terms:

numbers
d(x0)
if(true, x0)
if(false, x0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LE(s(x), s(y)) → LE(x, y)

R is empty.
The set Q consists of the following terms:

numbers
d(x0)
if(true, x0)
if(false, x0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

numbers
d(x0)
if(true, x0)
if(false, x0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LE(s(x), s(y)) → LE(x, y)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

LE(s(x), s(y)) → LE(x, y)
The graph contains the following edges 1 > 1, 2 > 2

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, nr), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

numbers → d(0)
d(x) → if(le(x, nr), x)
if(true, x) → cons(x, d(s(x)))
if(false, x) → nil
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
nr → ack(s(s(s(s(s(s(0)))))), 0)
ack(0, x) → s(x)
ack(s(x), 0) → ack(x, s(0))
ack(s(x), s(y)) → ack(x, ack(s(x), y))

The set Q consists of the following terms:

numbers
d(x0)
if(true, x0)
if(false, x0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, nr), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

nr → ack(s(s(s(s(s(s(0)))))), 0)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
ack(0, x) → s(x)

The set Q consists of the following terms:

numbers
d(x0)
if(true, x0)
if(false, x0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

numbers
d(x0)
if(true, x0)
if(false, x0)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, nr), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

nr → ack(s(s(s(s(s(s(0)))))), 0)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, nr), x) at position [0,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(s(s(0)))))), 0)), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(s(s(0)))))), 0)), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

nr → ack(s(s(s(s(s(s(0)))))), 0)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(s(s(0)))))), 0)), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
nr
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

nr

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(s(s(0)))))), 0)), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(s(s(0)))))), 0)), x) at position [0,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(s(0))))), s(0))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(s(0))))), s(0))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(s(0))))), s(0))), x) at position [0,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(s(s(0))))), 0))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(s(s(0))))), 0))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(s(s(0))))), 0))), x) at position [0,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(s(0)))), s(0)))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(s(0)))), s(0)))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(s(0)))), s(0)))), x) at position [0,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(s(s(0)))), 0)))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(s(s(0)))), 0)))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(s(s(0)))), 0)))), x) at position [0,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(s(0))), s(0))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(s(0))), s(0))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(s(0))), s(0))))), x) at position [0,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(s(s(0))), 0))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(true, x) → D(s(x))
D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(s(s(0))), 0))))), x)

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(s(s(0))), 0))))), x) at position [0,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(s(0)), s(0)))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(s(0)), s(0)))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(s(0)), s(0)))))), x) at position [0,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(0), ack(s(s(0)), 0)))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(0), ack(s(s(0)), 0)))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(0), ack(s(s(0)), 0)))))), x) at position [0,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(0), ack(s(0), s(0))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(0), ack(s(0), s(0))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(0), ack(s(0), s(0))))))), x) at position [0,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(0), ack(0, ack(s(0), 0))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(0), ack(0, ack(s(0), 0))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(0), ack(0, ack(s(0), 0))))))), x) at position [0,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(0), s(ack(s(0), 0))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(0), s(ack(s(0), 0))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(s(0), s(ack(s(0), 0))))))), x) at position [0,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(0, ack(s(0), ack(s(0), 0))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(0, ack(s(0), ack(s(0), 0))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), ack(0, ack(s(0), ack(s(0), 0))))))), x) at position [0,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), s(ack(s(0), ack(s(0), 0))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), s(ack(s(0), ack(s(0), 0))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(s(0)), s(ack(s(0), ack(s(0), 0))))))), x) at position [0,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), ack(s(0), ack(s(0), 0))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), ack(s(0), ack(s(0), 0))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), ack(s(0), ack(s(0), 0))))))), x) at position [0,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), ack(s(0), ack(0, s(0)))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), ack(s(0), ack(0, s(0)))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), ack(s(0), ack(0, s(0)))))))), x) at position [0,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), ack(s(0), s(s(0)))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(true, x) → D(s(x))
D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), ack(s(0), s(s(0)))))))), x)

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), ack(s(0), s(s(0)))))))), x) at position [0,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), ack(0, ack(s(0), s(0)))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), ack(0, ack(s(0), s(0)))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), ack(0, ack(s(0), s(0)))))))), x) at position [0,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), s(ack(s(0), s(0)))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), s(ack(s(0), s(0)))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(s(0)), s(ack(s(0), s(0)))))))), x) at position [0,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(s(0)), ack(s(0), s(0)))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(s(0)), ack(s(0), s(0)))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(s(0)), ack(s(0), s(0)))))))), x) at position [0,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(s(0)), ack(0, ack(s(0), 0)))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(s(0)), ack(0, ack(s(0), 0)))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(s(0)), ack(0, ack(s(0), 0)))))))), x) at position [0,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(s(0)), s(ack(s(0), 0)))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(s(0)), s(ack(s(0), 0)))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(s(0)), s(ack(s(0), 0)))))))), x) at position [0,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), ack(s(0), 0)))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), ack(s(0), 0)))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), ack(s(0), 0)))))))), x) at position [0,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), ack(0, s(0))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), ack(0, s(0))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), ack(0, s(0))))))))), x) at position [0,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), s(s(0))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), s(s(0))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), s(s(0))))))))), x) at position [0,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), s(0))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), s(0))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), s(0))))))))), x) at position [0,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), 0))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), 0))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(s(0)), 0))))))))), x) at position [0,1,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(0)))))))))), x) at position [0,1,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), 0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), 0)))))))))), x) at position [0,1,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), 0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), 0)))))))))), x) at position [0,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), 0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), 0)))))))))), x) at position [0,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), 0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), 0)))))))))), x) at position [0,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x) at position [0,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x) at position [0,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x) at position [0,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x) at position [0,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x) at position [0,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), s(ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), s(ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(s(0), s(ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x) at position [0,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x) at position [0,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), s(ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(true, x) → D(s(x))
D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), s(ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(s(0))), s(ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x) at position [0,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), 0)))))))))), x) at position [0,1,1,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(0, s(0))))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(0, s(0))))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(0, s(0))))))))))), x) at position [0,1,1,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(s(0))))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(s(0))))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(s(0))))))))))), x) at position [0,1,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), s(0))))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(true, x) → D(s(x))
D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), s(0))))))))))), x)

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), s(0))))))))))), x) at position [0,1,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), s(0))))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), s(0))))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), s(0))))))))))), x) at position [0,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), s(0))))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), s(0))))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), s(0))))))))))), x) at position [0,1,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), s(0))))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), s(0))))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), s(0))))))))))), x) at position [0,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), s(0))))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), s(0))))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), s(0))))))))))), x) at position [0,1,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), ack(s(0), s(0))))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(true, x) → D(s(x))
D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), ack(s(0), s(0))))))))))), x)

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(s(0), s(ack(s(0), ack(s(0), ack(s(0), s(0))))))))))), x) at position [0,1,1,1,1,1] we obtained the following new rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(0))))))))))), x)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ RemovalProof

Q DP problem:
The TRS P consists of the following rules:

D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(0))))))))))), x)
IF(true, x) → D(s(x))

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(0)))))))))) is replaced by the fresh variable x_removed.
Pair: D(x) → IF(le(x, ack(s(s(s(s(0)))), ack(s(s(0)), ack(s(s(s(0))), ack(s(0), ack(0, ack(s(0), ack(s(0), ack(s(0), ack(s(0), s(0))))))))))), x)
Positions in right side of the pair:

[0,1]

The following rules were checked for non-overlappingness:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
ack(0, x) → s(x)

The new variable was added to all pairs as a new argument[13].

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ RemovalProof

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ NonInfProof

Q DP problem:
The TRS P consists of the following rules:

IF(true, x, x_removed) → D(s(x), x_removed)
D(x, x_removed) → IF(le(x, x_removed), x, x_removed)

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The DP Problem is simplified using the Induction Calculus [18] with the following steps:
Note that final constraints are written in bold face.

For Pair IF(true, x, x_removed) → D(s(x), x_removed) the following chains were created:

We consider the chain D(x, x_removed) → IF(le(x, x_removed), x, x_removed), IF(true, x, x_removed) → D(s(x), x_removed) which results in the following constraint:
(1)    (IF(le(x2, x3), x2, x3)=IF(true, x4, x5) ⇒ IF(true, x4, x5)≥D(s(x4), x5))

We simplified constraint (1) using rules (I), (II), (III) which results in the following new constraint:
(2)    (le(x2, x3)=true ⇒ IF(true, x2, x3)≥D(s(x2), x3))

We simplified constraint (2) using rule (V) (with possible (I) afterwards) using induction on le(x2, x3)=true which results in the following new constraints:
(3)    (true=true ⇒ IF(true, 0, x12)≥D(s(0), x12))

(4)    (le(x14, x15)=true∧(le(x14, x15)=true ⇒ IF(true, x14, x15)≥D(s(x14), x15)) ⇒ IF(true, s(x14), s(x15))≥D(s(s(x14)), s(x15)))

We simplified constraint (3) using rules (I), (II) which results in the following new constraint:
(5)    (IF(true, 0, x12)≥D(s(0), x12))

We simplified constraint (4) using rule (VI) where we applied the induction hypothesis (le(x14, x15)=true ⇒ IF(true, x14, x15)≥D(s(x14), x15)) with σ = [ ] which results in the following new constraint:
(6)    (IF(true, x14, x15)≥D(s(x14), x15) ⇒ IF(true, s(x14), s(x15))≥D(s(s(x14)), s(x15)))

For Pair D(x, x_removed) → IF(le(x, x_removed), x, x_removed) the following chains were created:

We consider the chain IF(true, x, x_removed) → D(s(x), x_removed), D(x, x_removed) → IF(le(x, x_removed), x, x_removed) which results in the following constraint:
(7) (D(s(x6), x7)=D(x8, x9) ⇒ D(x8, x9)≥IF(le(x8, x9), x8, x9))

We simplified constraint (7) using rules (I), (II), (III) which results in the following new constraint:
(8) (D(s(x6), x7)≥IF(le(s(x6), x7), s(x6), x7))

To summarize, we get the following constraints P_≥ for the following pairs.

IF(true, x, x_removed) → D(s(x), x_removed)
- (IF(true, 0, x12)≥D(s(0), x12))
- (IF(true, x14, x15)≥D(s(x14), x15) ⇒ IF(true, s(x14), s(x15))≥D(s(s(x14)), s(x15)))
D(x, x_removed) → IF(le(x, x_removed), x, x_removed)
- (D(s(x6), x7)≥IF(le(s(x6), x7), s(x6), x7))

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation [18]:

POL(0) = 0
POL(D(x₁, x₂)) = -1 - x₁ + x₂
POL(IF(x₁, x₂, x₃)) = -1 - x₁ - x₂ + x₃
POL(c) = -2
POL(false) = 0
POL(le(x₁, x₂)) = 0
POL(s(x₁)) = 1 + x₁
POL(true) = 0

The following pairs are in P_>:

IF(true, x, x_removed) → D(s(x), x_removed)

The following pairs are in P_bound:

IF(true, x, x_removed) → D(s(x), x_removed)

The following rules are usable:

true → le(0, y)
false → le(s(x), 0)
le(x, y) → le(s(x), s(y))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ UsableRulesProof

                              ↳ QDP

                                ↳ QReductionProof

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ Rewriting

                                                                                                              ↳ QDP

                                                                                                                ↳ Rewriting

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Rewriting

                                                                                                                      ↳ QDP

                                                                                                                        ↳ Rewriting

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Rewriting

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ Rewriting

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ Rewriting

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ RemovalProof

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ NonInfProof

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

D(x, x_removed) → IF(le(x, x_removed), x, x_removed)

The TRS R consists of the following rules:

ack(s(x), s(y)) → ack(x, ack(s(x), y))
ack(s(x), 0) → ack(x, s(0))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
ack(0, x) → s(x)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
ack(0, x0)
ack(s(x0), 0)
ack(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 1 less node.